home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 2002 November / SGI Freeware 2002 November - Disc 1.iso / dist / fw_gd.idb / usr / freeware / include / gd.h.z / gd.h
C/C++ Source or Header  |  2002-04-08  |  10KB  |  276 lines
  1. #ifndef GD_H
  2. #define GD_H 1
  3.  
  4. #ifdef __cplusplus
  5. extern "C" {
  6. #endif
  7.  
  8. /* default fontpath for unix systems */
  9. #define DEFAULT_FONTPATH "/usr/share/fonts/truetype"
  10. #define PATHSEPARATOR ":"
  11.  
  12. /* gd.h: declarations file for the graphic-draw module.
  13.  * Permission to use, copy, modify, and distribute this software and its
  14.  * documentation for any purpose and without fee is hereby granted, provided
  15.  * that the above copyright notice appear in all copies and that both that
  16.  * copyright notice and this permission notice appear in supporting
  17.  * documentation.  This software is provided "AS IS." Thomas Boutell and
  18.  * Boutell.Com, Inc. disclaim all warranties, either express or implied, 
  19.  * including but not limited to implied warranties of merchantability and 
  20.  * fitness for a particular purpose, with respect to this code and accompanying
  21.  * documentation. */
  22.  
  23. /* stdio is needed for file I/O. */
  24. #include <stdio.h>
  25. #include "gd_io.h"
  26.  
  27. /* This can't be changed in the current palette-only version of gd. */
  28.  
  29. #define gdMaxColors 256
  30.  
  31. /* Image type. See functions below; you will not need to change
  32.     the elements directly. Use the provided macros to
  33.     access sx, sy, the color table, and colorsTotal for 
  34.     read-only purposes. */
  35.  
  36. typedef struct gdImageStruct {
  37.     unsigned char ** pixels;
  38.     int sx;
  39.     int sy;
  40.     int colorsTotal;
  41.     int red[gdMaxColors];
  42.     int green[gdMaxColors];
  43.     int blue[gdMaxColors]; 
  44.     int open[gdMaxColors];
  45.     int transparent;
  46.     int *polyInts;
  47.     int polyAllocated;
  48.     struct gdImageStruct *brush;
  49.     struct gdImageStruct *tile;    
  50.     int brushColorMap[gdMaxColors];
  51.     int tileColorMap[gdMaxColors];
  52.     int styleLength;
  53.     int stylePos;
  54.     int *style;
  55.     int interlace;
  56. } gdImage;
  57.  
  58. typedef gdImage * gdImagePtr;
  59.  
  60. typedef struct {
  61.     /* # of characters in font */
  62.     int nchars;
  63.     /* First character is numbered... (usually 32 = space) */
  64.     int offset;
  65.     /* Character width and height */
  66.     int w;
  67.     int h;
  68.     /* Font data; array of characters, one row after another.
  69.         Easily included in code, also easily loaded from
  70.         data files. */
  71.     char *data;
  72. } gdFont;
  73.  
  74. /* Text functions take these. */
  75. typedef gdFont *gdFontPtr;
  76.  
  77. /* For backwards compatibility only. Use gdImageSetStyle()
  78.     for MUCH more flexible line drawing. Also see
  79.     gdImageSetBrush(). */
  80. #define gdDashSize 4
  81.  
  82. /* Special colors. */
  83.  
  84. #define gdStyled (-2)
  85. #define gdBrushed (-3)
  86. #define gdStyledBrushed (-4)
  87. #define gdTiled (-5)
  88.  
  89. /* NOT the same as the transparent color index.
  90.     This is used in line styles only. */
  91. #define gdTransparent (-6)
  92.  
  93. /* Functions to manipulate images. */
  94.  
  95. gdImagePtr gdImageCreate(int sx, int sy);
  96. gdImagePtr gdImageCreateFromPng(FILE *fd);
  97. gdImagePtr gdImageCreateFromPngCtx(gdIOCtxPtr in);
  98. gdImagePtr gdImageCreateFromWBMP(FILE *inFile);
  99. gdImagePtr gdImageCreateFromWBMPCtx(gdIOCtx *infile); 
  100. gdImagePtr gdImageCreateFromJpeg(FILE *infile);
  101. gdImagePtr gdImageCreateFromJpegCtx(gdIOCtx *infile);
  102.  
  103. /* A custom data source. */
  104. /* The source function must return -1 on error, otherwise the number
  105.         of bytes fetched. 0 is EOF, not an error! */
  106. /* context will be passed to your source function. */
  107.  
  108. typedef struct {
  109.         int (*source) (void *context, char *buffer, int len);
  110.         void *context;
  111. } gdSource, *gdSourcePtr;
  112.  
  113. gdImagePtr gdImageCreateFromPngSource(gdSourcePtr in);
  114.  
  115. gdImagePtr gdImageCreateFromGd(FILE *in);
  116. gdImagePtr gdImageCreateFromGdCtx(gdIOCtxPtr in);
  117.  
  118. gdImagePtr gdImageCreateFromGd2(FILE *in);
  119. gdImagePtr gdImageCreateFromGd2Ctx(gdIOCtxPtr in);
  120.  
  121. gdImagePtr gdImageCreateFromGd2Part(FILE *in, int srcx, int srcy, int w, int h);
  122. gdImagePtr gdImageCreateFromGd2PartCtx(gdIOCtxPtr in, int srcx, int srcy, int w, int h);
  123.  
  124. gdImagePtr gdImageCreateFromXbm(FILE *fd);
  125.  
  126. void gdImageDestroy(gdImagePtr im);
  127. void gdImageSetPixel(gdImagePtr im, int x, int y, int color);
  128. int gdImageGetPixel(gdImagePtr im, int x, int y);
  129. void gdImageLine(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
  130. /* For backwards compatibility only. Use gdImageSetStyle()
  131.     for much more flexible line drawing. */
  132. void gdImageDashedLine(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
  133. /* Corners specified (not width and height). Upper left first, lower right
  134.      second. */
  135. void gdImageRectangle(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
  136. /* Solid bar. Upper left corner first, lower right corner second. */
  137. void gdImageFilledRectangle(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
  138. int gdImageBoundsSafe(gdImagePtr im, int x, int y);
  139. void gdImageChar(gdImagePtr im, gdFontPtr f, int x, int y, int c, int color);
  140. void gdImageCharUp(gdImagePtr im, gdFontPtr f, int x, int y, int c, int color);
  141. void gdImageString(gdImagePtr im, gdFontPtr f, int x, int y, unsigned char *s, int color);
  142. void gdImageStringUp(gdImagePtr im, gdFontPtr f, int x, int y, unsigned char *s, int color);
  143. void gdImageString16(gdImagePtr im, gdFontPtr f, int x, int y, unsigned short *s, int color);
  144. void gdImageStringUp16(gdImagePtr im, gdFontPtr f, int x, int y, unsigned short *s, int color);
  145.  
  146. /* FreeType 1.x text output (DEPRECATED) */
  147. char *gdImageStringTTF(gdImage *im, int *brect, int fg, char *fontlist,
  148.                 double ptsize, double angle, int x, int y, char *string);
  149.  
  150. /* FreeType 2 text output (NIFTY) */
  151. char *gdImageStringFT(gdImage *im, int *brect, int fg, char *fontlist,
  152.                 double ptsize, double angle, int x, int y, char *string);
  153.  
  154. /* Point type for use in polygon drawing. */
  155. typedef struct {
  156.     int x, y;
  157. } gdPoint, *gdPointPtr;
  158.  
  159. void gdImagePolygon(gdImagePtr im, gdPointPtr p, int n, int c);
  160. void gdImageFilledPolygon(gdImagePtr im, gdPointPtr p, int n, int c);
  161.  
  162. int gdImageColorAllocate(gdImagePtr im, int r, int g, int b);
  163. int gdImageColorClosest(gdImagePtr im, int r, int g, int b);
  164. int gdImageColorExact(gdImagePtr im, int r, int g, int b);
  165. int gdImageColorResolve(gdImagePtr im, int r, int g, int b);
  166. void gdImageColorDeallocate(gdImagePtr im, int color);
  167. void gdImageColorTransparent(gdImagePtr im, int color);
  168. void gdImagePaletteCopy(gdImagePtr dst, gdImagePtr src);
  169. void gdImagePng(gdImagePtr im, FILE *out);
  170. void gdImagePngCtx(gdImagePtr im, gdIOCtx *out);
  171.  
  172. void gdImageWBMP(gdImagePtr image, int fg, FILE *out);
  173. void gdImageWBMPCtx(gdImagePtr image, int fg, gdIOCtx *out);
  174.  
  175. /* Guaranteed to correctly free memory returned
  176.     by the gdImage*Ptr functions */
  177. void gdFree(void *m);
  178.  
  179. /* Best to free this memory with gdFree(), not free() */
  180. void *gdImageWBMPPtr(gdImagePtr im, int *size, int fg);
  181.  
  182. void gdImageJpeg(gdImagePtr im, FILE *out, int quality);
  183. void gdImageJpegCtx(gdImagePtr im, gdIOCtx *out, int quality);
  184.  
  185. /* Best to free this memory with gdFree(), not free() */
  186. void *gdImageJpegPtr(gdImagePtr im, int *size, int quality);
  187.  
  188. /* A custom data sink. For backwards compatibility. Use
  189.     gdIOCtx instead. */
  190. /* The sink function must return -1 on error, otherwise the number
  191.         of bytes written, which must be equal to len. */
  192. /* context will be passed to your sink function. */
  193. typedef struct {
  194.         int (*sink) (void *context, const char *buffer, int len);
  195.         void *context;
  196. } gdSink, *gdSinkPtr;
  197.  
  198. void gdImagePngToSink(gdImagePtr im, gdSinkPtr out);
  199.  
  200. void gdImageGd(gdImagePtr im, FILE *out);
  201. void gdImageGd2(gdImagePtr im, FILE *out, int cs, int fmt);
  202.  
  203. /* Best to free this memory with gdFree(), not free() */
  204. void* gdImagePngPtr(gdImagePtr im, int *size);
  205.  
  206. /* Best to free this memory with gdFree(), not free() */
  207. void* gdImageGdPtr(gdImagePtr im, int *size);
  208.  
  209. /* Best to free this memory with gdFree(), not free() */
  210. void* gdImageGd2Ptr(gdImagePtr im, int cs, int fmt, int *size);
  211.  
  212. void gdImageArc(gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color);
  213. void gdImageFillToBorder(gdImagePtr im, int x, int y, int border, int color);
  214. void gdImageFill(gdImagePtr im, int x, int y, int color);
  215. void gdImageCopy(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h);
  216. void gdImageCopyMerge(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, 
  217.             int srcX, int srcY, int w, int h, int pct);
  218. void gdImageCopyMergeGray(gdImagePtr dst, gdImagePtr src, int dstX, int dstY,
  219.                         int srcX, int srcY, int w, int h, int pct);
  220.  
  221. /* Stretches or shrinks to fit, as needed */
  222. void gdImageCopyResized(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH);
  223. void gdImageSetBrush(gdImagePtr im, gdImagePtr brush);
  224. void gdImageSetTile(gdImagePtr im, gdImagePtr tile);
  225. void gdImageSetStyle(gdImagePtr im, int *style, int noOfPixels);
  226. /* On or off (1 or 0) */
  227. void gdImageInterlace(gdImagePtr im, int interlaceArg);
  228.  
  229. /* Macros to access information about images. READ ONLY. Changing
  230.     these values will NOT have the desired result. */
  231. #define gdImageSX(im) ((im)->sx)
  232. #define gdImageSY(im) ((im)->sy)
  233. #define gdImageColorsTotal(im) ((im)->colorsTotal)
  234. #define gdImageRed(im, c) ((im)->red[(c)])
  235. #define gdImageGreen(im, c) ((im)->green[(c)])
  236. #define gdImageBlue(im, c) ((im)->blue[(c)])
  237. #define gdImageGetTransparent(im) ((im)->transparent)
  238. #define gdImageGetInterlaced(im) ((im)->interlace)
  239.  
  240. /* I/O Support routines. */
  241.  
  242. gdIOCtx* gdNewFileCtx(FILE*);
  243. gdIOCtx* gdNewDynamicCtx(int, void*);
  244. gdIOCtx* gdNewSSCtx(gdSourcePtr in, gdSinkPtr out);
  245. void* gdDPExtractData(struct gdIOCtx* ctx, int *size);
  246.  
  247. #define GD2_CHUNKSIZE           128 
  248. #define GD2_CHUNKSIZE_MIN    64
  249. #define GD2_CHUNKSIZE_MAX       4096
  250.  
  251. #define GD2_VERS                1
  252. #define GD2_ID                  "gd2"
  253. #define GD2_FMT_RAW             1
  254. #define GD2_FMT_COMPRESSED      2
  255.  
  256. /* Image comparison definitions */
  257. int gdImageCompare(gdImagePtr im1, gdImagePtr im2);
  258.  
  259. #define GD_CMP_IMAGE        1    /* Actual image IS different */
  260. #define GD_CMP_NUM_COLORS    2    /* Number of Colours in pallette differ */
  261. #define GD_CMP_COLOR        4    /* Image colours differ */
  262. #define GD_CMP_SIZE_X        8    /* Image width differs */
  263. #define GD_CMP_SIZE_Y        16    /* Image heights differ */
  264. #define GD_CMP_TRANSPARENT    32    /* Transparent colour */
  265. #define GD_CMP_BACKGROUND    64    /* Background colour */
  266. #define GD_CMP_INTERLACE    128    /* Interlaced setting */
  267.  
  268. /* resolution affects ttf font rendering, particularly hinting */
  269. #define GD_RESOLUTION           96      /* pixels per inch */
  270.  
  271. #ifdef __cplusplus
  272. }
  273. #endif
  274.  
  275. #endif /* GD_H */
  276.